/**
 * 通用工具函数
 */

class CommonUtils {
	/**
	 * 格式化时间显示
	 * @param {number} seconds 秒数
	 * @returns {string} 格式化的时间字符串
	 */
	static formatTime(seconds) {
		if (seconds < 60) {
			return `${Math.round(seconds)}秒`;
		}
		
		const minutes = Math.floor(seconds / 60);
		const remainingSeconds = Math.round(seconds % 60);
		
		if (minutes < 60) {
			return `${minutes}分${remainingSeconds}秒`;
		}
		
		const hours = Math.floor(minutes / 60);
		const remainingMinutes = minutes % 60;
		return `${hours}小时${remainingMinutes}分${remainingSeconds}秒`;
	}
	
	/**
	 * 格式化日期显示
	 * @param {Date|string} date 日期
	 * @returns {string} 格式化的日期字符串
	 */
	static formatDate(date) {
		const d = new Date(date);
		const year = d.getFullYear();
		const month = String(d.getMonth() + 1).padStart(2, '0');
		const day = String(d.getDate()).padStart(2, '0');
		const hours = String(d.getHours()).padStart(2, '0');
		const minutes = String(d.getMinutes()).padStart(2, '0');
		
		return `${year}-${month}-${day} ${hours}:${minutes}`;
	}
	
	/**
	 * 格式化分数显示
	 * @param {number} numerator 分子
	 * @param {number} denominator 分母
	 * @returns {string} 格式化的分数字符串
	 */
	static formatFraction(numerator, denominator) {
		return `${numerator}/${denominator}`;
	}
	
	/**
	 * 深拷贝对象
	 * @param {any} obj 要拷贝的对象
	 * @returns {any} 拷贝后的对象
	 */
	static deepClone(obj) {
		if (obj === null || typeof obj !== 'object') {
			return obj;
		}
		
		if (obj instanceof Date) {
			return new Date(obj.getTime());
		}
		
		if (obj instanceof Array) {
			return obj.map(item => this.deepClone(item));
		}
		
		if (typeof obj === 'object') {
			const cloned = {};
			for (const key in obj) {
				if (obj.hasOwnProperty(key)) {
					cloned[key] = this.deepClone(obj[key]);
				}
			}
			return cloned;
		}
	}
	
	/**
	 * 防抖函数
	 * @param {Function} func 要防抖的函数
	 * @param {number} wait 等待时间
	 * @returns {Function} 防抖后的函数
	 */
	static debounce(func, wait) {
		let timeout;
		return function executedFunction(...args) {
			const later = () => {
				clearTimeout(timeout);
				func(...args);
			};
			clearTimeout(timeout);
			timeout = setTimeout(later, wait);
		};
	}
	
	/**
	 * 节流函数
	 * @param {Function} func 要节流的函数
	 * @param {number} limit 时间限制
	 * @returns {Function} 节流后的函数
	 */
	static throttle(func, limit) {
		let inThrottle;
		return function() {
			const args = arguments;
			const context = this;
			if (!inThrottle) {
				func.apply(context, args);
				inThrottle = true;
				setTimeout(() => inThrottle = false, limit);
			}
		};
	}
	
	/**
	 * 生成随机ID
	 * @param {number} length ID长度
	 * @returns {string} 随机ID
	 */
	static generateId(length = 8) {
		const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
		let result = '';
		for (let i = 0; i < length; i++) {
			result += chars.charAt(Math.floor(Math.random() * chars.length));
		}
		return result;
	}
	
	/**
	 * 验证数字输入（用于提交时的最终验证）
	 * @param {string} input 输入值
	 * @returns {boolean} 是否为有效数字
	 */
	static isValidNumber(input) {
		if (typeof input === 'number') {
			return !isNaN(input) && isFinite(input);
		}
		
		if (typeof input === 'string') {
			const trimmed = input.trim();
			if (trimmed === '' || trimmed === '.' || trimmed === '-' || trimmed === '+') return false;
			
			// 尝试解析为数字
			const number = parseFloat(trimmed);
			return !isNaN(number) && isFinite(number);
		}
		
		return false;
	}
	
	/**
	 * 显示提示消息
	 * @param {string} title 标题
	 * @param {string} icon 图标类型
	 * @param {number} duration 持续时间
	 */
	static showToast(title, icon = 'none', duration = 2000) {
		uni.showToast({
			title,
			icon,
			duration
		});
	}
	
	/**
	 * 显示加载提示
	 * @param {string} title 提示文字
	 */
	static showLoading(title = '加载中...') {
		uni.showLoading({
			title
		});
	}
	
	/**
	 * 隐藏加载提示
	 */
	static hideLoading() {
		uni.hideLoading();
	}
}

export default CommonUtils;